home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / dcerpc.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2006-06-30  |  38KB  |  1,063 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import array
  5. from binascii import crc32
  6.  
  7. try:
  8.     from Crypto.Cipher import ARC4
  9.     from Crypto.Hash import MD4
  10.     POW = None
  11. except Exception:
  12.     
  13.     try:
  14.         import POW
  15.     except Exception:
  16.         print 'WARNING: Crypto package not found. Some features will fail.'
  17.  
  18.  
  19. from impacket import ntlm
  20. from impacket import ImpactPacket
  21. from impacket.structure import Structure, pack, unpack
  22. MSRPC_REQUEST = 0
  23. MSRPC_RESPONSE = 2
  24. MSRPC_FAULT = 3
  25. MSRPC_ACK = 7
  26. MSRPC_BIND = 11
  27. MSRPC_BINDACK = 12
  28. MSRPC_BINDNAK = 13
  29. MSRPC_ALTERCTX = 14
  30. MSRPC_AUTH3 = 16
  31. MSRPC_FIRSTFRAG = 1
  32. MSRPC_LASTFRAG = 2
  33. MSRPC_NOTAFRAG = 4
  34. MSRPC_RECRESPOND = 8
  35. MSRPC_NOMULTIPLEX = 16
  36. MSRPC_NOTFORIDEMP = 32
  37. MSRPC_NOTFORBCAST = 64
  38. MSRPC_NOUUID = 128
  39. rpc_provider_reason = {
  40.     0: 'reason_not_specified',
  41.     1: 'abstract_syntax_not_supported',
  42.     2: 'proposed_transfer_syntaxes_not_supported',
  43.     3: 'local_limit_exceeded' }
  44. MSRPC_CONT_RESULT_ACCEPT = 0
  45. MSRPC_CONT_RESULT_USER_REJECT = 1
  46. MSRPC_CONT_RESULT_PROV_REJECT = 2
  47. rpc_cont_def_result = {
  48.     0: 'acceptance',
  49.     1: 'user_rejection',
  50.     2: 'provider_rejection' }
  51. rpc_status_codes = {
  52.     0x5L: 'rpc_s_access_denied',
  53.     0x8L: 'Authentication type not recognized',
  54.     0x6C6L: 'rpc_x_invalid_bound',
  55.     0x6F7L: 'rpc_x_bad_stub_data',
  56.     0x1C010001L: 'nca_s_comm_failure',
  57.     0x1C010002L: 'nca_s_op_rng_error',
  58.     0x1C010003L: 'nca_s_unk_if',
  59.     0x1C010006L: 'nca_s_wrong_boot_time',
  60.     0x1C010009L: 'nca_s_you_crashed',
  61.     0x1C01000BL: 'nca_s_proto_error',
  62.     0x1C010013L: 'nca_s_out_args_too_big ',
  63.     0x1C010014L: 'nca_s_server_too_busy',
  64.     0x1C010015L: 'nca_s_fault_string_too_long',
  65.     0x1C010017L: 'nca_s_unsupported_type ',
  66.     0x1C000001L: 'nca_s_fault_int_div_by_zero',
  67.     0x1C000002L: 'nca_s_fault_addr_error ',
  68.     0x1C000003L: 'nca_s_fault_fp_div_zero',
  69.     0x1C000004L: 'nca_s_fault_fp_underflow',
  70.     0x1C000005L: 'nca_s_fault_fp_overflow',
  71.     0x1C000006L: 'nca_s_fault_invalid_tag',
  72.     0x1C000007L: 'nca_s_fault_invalid_bound ',
  73.     0x1C000008L: 'nca_s_rpc_version_mismatch',
  74.     0x1C000009L: 'nca_s_unspec_reject ',
  75.     0x1C00000AL: 'nca_s_bad_actid',
  76.     0x1C00000BL: 'nca_s_who_are_you_failed',
  77.     0x1C00000CL: 'nca_s_manager_not_entered ',
  78.     0x1C00000DL: 'nca_s_fault_cancel',
  79.     0x1C00000EL: 'nca_s_fault_ill_inst',
  80.     0x1C00000FL: 'nca_s_fault_fp_error',
  81.     0x1C000010L: 'nca_s_fault_int_overflow',
  82.     0x1C000012L: 'nca_s_fault_unspec',
  83.     0x1C000013L: 'nca_s_fault_remote_comm_failure ',
  84.     0x1C000014L: 'nca_s_fault_pipe_empty ',
  85.     0x1C000015L: 'nca_s_fault_pipe_closed',
  86.     0x1C000016L: 'nca_s_fault_pipe_order ',
  87.     0x1C000017L: 'nca_s_fault_pipe_discipline',
  88.     0x1C000018L: 'nca_s_fault_pipe_comm_error',
  89.     0x1C000019L: 'nca_s_fault_pipe_memory',
  90.     0x1C00001AL: 'nca_s_fault_context_mismatch ',
  91.     0x1C00001BL: 'nca_s_fault_remote_no_memory ',
  92.     0x1C00001CL: 'nca_s_invalid_pres_context_id',
  93.     0x1C00001DL: 'nca_s_unsupported_authn_level',
  94.     0x1C00001FL: 'nca_s_invalid_checksum ',
  95.     0x1C000020L: 'nca_s_invalid_crc',
  96.     0x1C000021L: 'nca_s_fault_user_defined',
  97.     0x1C000022L: 'nca_s_fault_tx_open_failed',
  98.     0x1C000023L: 'nca_s_fault_codeset_conv_error',
  99.     0x1C000024L: 'nca_s_fault_object_not_found ',
  100.     0x1C000025L: 'nca_s_fault_no_client_stub' }
  101.  
  102. class MSRPCArray:
  103.     
  104.     def __init__(self, id = 0, len = 0, size = 0):
  105.         self._length = len
  106.         self._size = size
  107.         self._id = id
  108.         self._max_len = 0
  109.         self._offset = 0
  110.         self._length2 = 0
  111.         self._name = ''
  112.  
  113.     
  114.     def set_max_len(self, n):
  115.         self._max_len = n
  116.  
  117.     
  118.     def set_offset(self, n):
  119.         self._offset = n
  120.  
  121.     
  122.     def set_length2(self, n):
  123.         self._length2 = n
  124.  
  125.     
  126.     def get_size(self):
  127.         return self._size
  128.  
  129.     
  130.     def set_name(self, n):
  131.         self._name = n
  132.  
  133.     
  134.     def get_name(self):
  135.         return self._name
  136.  
  137.     
  138.     def get_id(self):
  139.         return self._id
  140.  
  141.     
  142.     def rawData(self):
  143.         return pack('<HHLLLL', self._length, self._size, 305419896, self._max_len, self._offset, self._length2) + self._name.encode('utf-16le')
  144.  
  145.  
  146.  
  147. class MSRPCNameArray:
  148.     
  149.     def __init__(self, data = None):
  150.         self._count = 0
  151.         self._max_count = 0
  152.         self._elements = []
  153.         if data:
  154.             self.load(data)
  155.         
  156.  
  157.     
  158.     def load(self, data):
  159.         ptr = unpack('<L', data[:4])[0]
  160.         index = 4
  161.         if 0 == ptr:
  162.             return None
  163.         
  164.         (self._count, _, self._max_count) = unpack('<LLL', data[index:index + 12])
  165.         index += 12
  166.         for i in range(0, self._count):
  167.             (aindex, length, size, _) = unpack('<LHHL', data[index:index + 12])
  168.             self._elements.append(MSRPCArray(aindex, length, size))
  169.             index += 12
  170.         
  171.         for element in self._elements:
  172.             (max_len, offset, curlen) = unpack('<LLL', data[index:index + 12])
  173.             index += 12
  174.             element.set_name(unicode(data[index:index + 2 * curlen], 'utf-16le'))
  175.             element.set_max_len(max_len)
  176.             element.set_offset(offset)
  177.             element.set_length2(curlen)
  178.             index += 2 * curlen
  179.             if curlen & 1:
  180.                 index += 2
  181.                 continue
  182.         
  183.  
  184.     
  185.     def elements(self):
  186.         return self._elements
  187.  
  188.     
  189.     def rawData(self):
  190.         ret = pack('<LLLL', 1953789044, self._count, 1195853639, self._max_count)
  191.         pos_ret = []
  192.         for i in xrange(0, self._count):
  193.             ret += pack('<L', self._elements[i].get_id())
  194.             data = self._elements[i].rawData()
  195.             ret += data[:8]
  196.             pos_ret += data[8:]
  197.         
  198.         return ret + pos_ret
  199.  
  200.  
  201.  
  202. class MSRPCHeader(ImpactPacket.Header):
  203.     _SIZE = 16
  204.     commonHdr = (('ver_major', 'B'), ('ver_minor', 'B'), ('type', 'B=MSRPC_REQUEST'), ('flags', 'B=MSRPC_FIRSTFRAG | MSRPC_LASTFRAG'), ('represntation', '<L=0x10'), ('frag_len', '<H=24+len(data)+len(auth_data)'), ('auth_len', '<H=len(auth_data)-8'), ('call_id', '<L=1'))
  205.     structure = (('data', ':'), ('auth_data', ':'))
  206.     
  207.     def __init__(self, aBuffer = None, endianness = '<'):
  208.         ImpactPacket.Header.__init__(self, self._SIZE)
  209.         self.endianness = endianness
  210.         self.set_version((5, 0))
  211.         self.set_flags(MSRPC_FIRSTFRAG | MSRPC_LASTFRAG)
  212.         if endianness == '<':
  213.             self.set_representation(16)
  214.         else:
  215.             self.set_representation(0)
  216.         self._MSRPCHeader__frag_len_set = 0
  217.         self.set_auth_len(0)
  218.         self.set_call_id(1)
  219.         self.set_auth_data('')
  220.         if aBuffer:
  221.             self.load_header(aBuffer)
  222.         
  223.  
  224.     
  225.     def get_version(self):
  226.         ''' This method returns a tuple in (major, minor) form.'''
  227.         return (self.get_byte(0), self.get_byte(1))
  228.  
  229.     
  230.     def set_version(self, version):
  231.         ''' This method takes a tuple in (major, minor) form.'''
  232.         self.set_byte(0, version[0])
  233.         self.set_byte(1, version[1])
  234.  
  235.     
  236.     def get_type(self):
  237.         return self.get_byte(2)
  238.  
  239.     
  240.     def set_type(self, type):
  241.         self.set_byte(2, type)
  242.  
  243.     
  244.     def get_flags(self):
  245.         return self.get_byte(3)
  246.  
  247.     
  248.     def set_flags(self, flags):
  249.         self.set_byte(3, flags)
  250.  
  251.     
  252.     def get_representation(self):
  253.         return self.get_long(4, self.endianness)
  254.  
  255.     
  256.     def set_representation(self, representation):
  257.         self.set_long(4, representation, self.endianness)
  258.  
  259.     
  260.     def get_frag_len(self):
  261.         return self.get_word(8, self.endianness)
  262.  
  263.     
  264.     def set_frag_len(self, len):
  265.         self._MSRPCHeader__frag_len_set == 1
  266.         self.set_word(8, len, self.endianness)
  267.  
  268.     
  269.     def get_auth_len(self):
  270.         return self.get_word(10, self.endianness)
  271.  
  272.     
  273.     def set_auth_len(self, len):
  274.         self.set_word(10, len, self.endianness)
  275.  
  276.     
  277.     def set_auth_data(self, data):
  278.         self._auth_data = data
  279.  
  280.     
  281.     def get_call_id(self):
  282.         return self.get_long(12, self.endianness)
  283.  
  284.     
  285.     def set_call_id(self, id):
  286.         self.set_long(12, id, self.endianness)
  287.  
  288.     
  289.     def get_header_size(self):
  290.         return self._SIZE
  291.  
  292.     
  293.     def contains(self, aHeader):
  294.         ImpactPacket.Header.contains(self, aHeader)
  295.         if self.child():
  296.             self.set_op_num(self.child().OP_NUM)
  297.         
  298.  
  299.     
  300.     def set_alloc_hint(self, hint):
  301.         pass
  302.  
  303.     
  304.     def get_packet(self):
  305.         if self._auth_data:
  306.             self.set_auth_len(len(self._auth_data) - 8)
  307.         
  308.         if self.child():
  309.             contents_size = self.child().get_size()
  310.         else:
  311.             contents_size = 0
  312.         contents_size += len(self._auth_data)
  313.         if not self._MSRPCHeader__frag_len_set:
  314.             self.set_frag_len(self.get_header_size() + contents_size)
  315.         
  316.         self.set_alloc_hint(contents_size)
  317.         return ImpactPacket.Header.get_packet(self) + self._auth_data
  318.  
  319.  
  320.  
  321. class MSRPCRequestHeader(MSRPCHeader):
  322.     _SIZE = 24
  323.     structure = (('alloc_hint', '<L=frag_len'), ('ctx_id', '<H=0'), ('op_num', '<H'), ('data', ':'), ('auth_data', ':'))
  324.     
  325.     def __init__(self, aBuffer = None, endianness = '<'):
  326.         MSRPCHeader.__init__(self, aBuffer = aBuffer, endianness = endianness)
  327.         self.set_type(MSRPC_REQUEST)
  328.         self.set_ctx_id(0)
  329.         self.set_alloc_hint(0)
  330.  
  331.     
  332.     def get_alloc_hint(self):
  333.         return self.get_long(16, self.endianness)
  334.  
  335.     
  336.     def set_alloc_hint(self, len):
  337.         self.set_long(16, len, self.endianness)
  338.  
  339.     
  340.     def get_ctx_id(self):
  341.         return self.get_word(20, self.endianness)
  342.  
  343.     
  344.     def set_ctx_id(self, id):
  345.         self.set_word(20, id, self.endianness)
  346.  
  347.     
  348.     def get_op_num(self):
  349.         return self.get_word(22, self.endianness)
  350.  
  351.     
  352.     def set_op_num(self, op):
  353.         self.set_word(22, op, self.endianness)
  354.  
  355.  
  356.  
  357. class MSRPCRespHeader(MSRPCHeader):
  358.     _SIZE = 24
  359.     structure = (('alloc_hint', '<L=frag_len'), ('ctx_id', '<H=0'), ('cancel_count', '<B'), ('padding', '<B=0'), ('data', ':'), ('auth_data', ':'))
  360.     
  361.     def __init__(self, aBuffer = None, endianness = '<'):
  362.         MSRPCHeader.__init__(self, aBuffer = aBuffer, endianness = endianness)
  363.         self.set_type(MSRPC_RESPONSE)
  364.         self.set_ctx_id(0)
  365.         self.set_alloc_hint(0)
  366.  
  367.     
  368.     def get_alloc_hint(self):
  369.         return self.get_long(16, self.endianness)
  370.  
  371.     
  372.     def set_alloc_hint(self, len):
  373.         self.set_long(16, len, self.endianness)
  374.  
  375.     
  376.     def get_ctx_id(self):
  377.         return self.get_word(20, self.endianness)
  378.  
  379.     
  380.     def set_ctx_id(self, id):
  381.         self.set_word(20, id, self.endianness)
  382.  
  383.     
  384.     def get_cancel_count(self):
  385.         return self.get_byte(22)
  386.  
  387.  
  388.  
  389. class MSRPCBind(MSRPCHeader):
  390.     _SIZE = 72 - 44
  391.     structure = (('max_tfrag', '<H=4280'), ('max_rfrag', '<H=4280'), ('assoc_group', '<L=0'), ('ctx_num', 'B'))
  392.     
  393.     def __init__(self, aBuffer = None, endianness = '<'):
  394.         MSRPCHeader.__init__(self, aBuffer = aBuffer, endianness = endianness)
  395.         self.set_type(MSRPC_BIND)
  396.         self.set_max_tfrag(4280)
  397.         self.set_max_rfrag(4280)
  398.         self.set_assoc_group(0)
  399.         self.set_ctx_num(1)
  400.  
  401.     
  402.     def get_max_tfrag(self):
  403.         return self.get_word(16, self.endianness)
  404.  
  405.     
  406.     def set_max_tfrag(self, size):
  407.         self.set_word(16, size, self.endianness)
  408.  
  409.     
  410.     def get_max_rfrag(self):
  411.         return self.get_word(18, self.endianness)
  412.  
  413.     
  414.     def set_max_rfrag(self, size):
  415.         self.set_word(18, size, self.endianness)
  416.  
  417.     
  418.     def get_assoc_group(self):
  419.         return self.get_long(20, self.endianness)
  420.  
  421.     
  422.     def set_assoc_group(self, id):
  423.         self.set_long(20, id, self.endianness)
  424.  
  425.     
  426.     def get_ctx_num(self):
  427.         return self.get_byte(24)
  428.  
  429.     
  430.     def set_ctx_num(self, num):
  431.         self._SIZE = 28 + num * 44
  432.         self.set_byte(24, num)
  433.  
  434.     
  435.     def get_ctx_id(self, index = 0):
  436.         return self.get_word(28 + 44 * index, self.endianness)
  437.  
  438.     
  439.     def set_ctx_id(self, id, index = 0):
  440.         self.set_word(28 + 44 * index, id, self.endianness)
  441.  
  442.     
  443.     def get_trans_num(self, index = 0):
  444.         return self.get_byte(30 + 44 * index)
  445.  
  446.     
  447.     def set_trans_num(self, op, index = 0):
  448.         self.set_byte(30 + 44 * index, op)
  449.         self.set_byte(31 + 44 * index, 0)
  450.  
  451.     
  452.     def get_if_binuuid(self, index = 0):
  453.         return self.get_bytes().tolist()[32 + 44 * index:32 + 44 * index + 16]
  454.  
  455.     
  456.     def set_if_binuuid(self, binuuid, index = 0):
  457.         self.get_bytes()[32 + 44 * index:32 + len(binuuid) + 44 * index] = array.array('B', binuuid)
  458.  
  459.     
  460.     def set_if_ver(self, ver, minor, index = 0):
  461.         self.set_word(48 + 44 * index, ver, self.endianness)
  462.         self.set_word(50 + 44 * index, minor, self.endianness)
  463.  
  464.     
  465.     def get_if_ver(self, index = 0):
  466.         return self.get_word(48 + 44 * index, self.endianness)
  467.  
  468.     
  469.     def get_if_ver_minor(self, index = 0):
  470.         return self.get_word(50 + 44 * index, self.endianness)
  471.  
  472.     
  473.     def get_xfer_syntax_binuuid(self, index = 0):
  474.         return self.get_bytes().tolist()[52 + 44 * index:52 + 44 * index + 16]
  475.  
  476.     
  477.     def set_xfer_syntax_binuuid(self, binuuid, index = 0):
  478.         self.get_bytes()[52 + 44 * index:52 + len(binuuid) + 44 * index] = array.array('B', binuuid)
  479.  
  480.     
  481.     def set_xfer_syntax_ver(self, ver, index = 0):
  482.         self.set_long(68 + 44 * index, ver, self.endianness)
  483.  
  484.     
  485.     def get_xfer_syntax_ver(self, index = 0):
  486.         self.get_long(68 + 44 * index, ver, self.endianness)
  487.  
  488.  
  489.  
  490. class MSRPCBindAck(ImpactPacket.Header):
  491.     _SIZE = 56
  492.     
  493.     def __init__(self, aBuffer = None):
  494.         ImpactPacket.Header.__init__(self, self._SIZE)
  495.         self.set_type(MSRPC_BINDACK)
  496.         if aBuffer:
  497.             self.load_header(aBuffer)
  498.         
  499.  
  500.     
  501.     def get_version(self):
  502.         ''' This method returns a tuple in (major, minor) form.'''
  503.         return (self.get_byte(0), self.get_byte(1))
  504.  
  505.     
  506.     def set_version(self, version):
  507.         ''' This method takes a tuple in (major, minor) form.'''
  508.         self.set_byte(0, version[0])
  509.         self.set_byte(1, version[1])
  510.  
  511.     
  512.     def get_type(self):
  513.         return self.get_byte(2)
  514.  
  515.     
  516.     def set_type(self, type):
  517.         self.set_byte(2, type)
  518.  
  519.     
  520.     def get_flags(self):
  521.         return self.get_byte(3)
  522.  
  523.     
  524.     def set_flags(self, flags):
  525.         self.set_byte(3, flags)
  526.  
  527.     
  528.     def get_representation(self):
  529.         return self.get_long(4, '<')
  530.  
  531.     
  532.     def set_representation(self, representation):
  533.         self.set_long(4, representation, '<')
  534.  
  535.     
  536.     def get_frag_len(self):
  537.         return self.get_word(8, '<')
  538.  
  539.     
  540.     def set_frag_len(self, len):
  541.         self.set_word(8, len, '<')
  542.  
  543.     
  544.     def get_auth_len(self):
  545.         return self.get_word(10, '<')
  546.  
  547.     
  548.     def set_auth_len(self, len):
  549.         self.set_word(10, len, '<')
  550.  
  551.     
  552.     def get_auth_data(self):
  553.         data = self.get_bytes()
  554.         return data[-self.get_auth_len() - 8:]
  555.  
  556.     
  557.     def get_call_id(self):
  558.         return self.get_long(12, '<')
  559.  
  560.     
  561.     def set_call_id(self, id):
  562.         self.set_long(12, id, '<')
  563.  
  564.     
  565.     def get_max_tfrag(self):
  566.         return self.get_word(16, '<')
  567.  
  568.     
  569.     def set_max_tfrag(self, size):
  570.         self.set_word(16, size, '<')
  571.  
  572.     
  573.     def get_max_rfrag(self):
  574.         return self.get_word(18, '<')
  575.  
  576.     
  577.     def set_max_rfrag(self, size):
  578.         self.set_word(18, size, '<')
  579.  
  580.     
  581.     def get_assoc_group(self):
  582.         return self.get_long(20, '<')
  583.  
  584.     
  585.     def set_assoc_group(self, id):
  586.         self.set_long(20, id, '<')
  587.  
  588.     
  589.     def get_secondary_addr_len(self):
  590.         return self.get_word(24, '<')
  591.  
  592.     
  593.     def set_secondary_addr_len(self, len):
  594.         self.set_word(24, len, '<')
  595.  
  596.     
  597.     def get_secondary_addr(self):
  598.         return self.get_bytes().tolist()[26:26 + self.get_secondary_addr_len()]
  599.  
  600.     
  601.     def set_secondary_addr(self, addr):
  602.         self.get_bytes()[26:26 + self.get_secondary_addr_len()] = array.array('B', addr)
  603.         self.set_secondary_addr_len(len(addr))
  604.  
  605.     
  606.     def _get_results_offset(self):
  607.         answer = 26 + self.get_secondary_addr_len()
  608.         answer += 3
  609.         answer -= answer % 4
  610.         return answer + 2
  611.  
  612.     
  613.     def get_results_num(self):
  614.         return self.get_byte(self._get_results_offset() - 2)
  615.  
  616.     
  617.     def set_results_num(self, num):
  618.         self.set_byte(self._get_results_offset() - 2, num)
  619.  
  620.     
  621.     def get_result(self, index = 0):
  622.         return self.get_word(self._get_results_offset() + 2 * index, '<')
  623.  
  624.     
  625.     def set_result(self, res, index = 0):
  626.         self.set_word(self._get_results_offset() + 2 * index, '<')
  627.  
  628.     
  629.     def get_xfer_syntax_binuuid(self):
  630.         return self.get_bytes().tolist()[-20:]
  631.  
  632.     
  633.     def set_xfer_syntax_binuuid(self, binuuid):
  634.         if not 20 == len(binuuid):
  635.             raise AssertionError
  636.         self.get_bytes()[-20:] = array.array('B', binuuid)
  637.  
  638.     
  639.     def get_header_size(self):
  640.         var_size = len(self.get_bytes()) - self._SIZE
  641.         return self._SIZE + var_size
  642.  
  643.     
  644.     def contains(self, aHeader):
  645.         ImpactPacket.Header.contains(self, aHeader)
  646.         if self.child():
  647.             contents_size = self.child().get_size()
  648.             self.set_op_num(self.child().OP_NUM)
  649.             self.set_frag_len(self.get_header_size() + contents_size)
  650.             self.set_alloc_hint(contents_size)
  651.         
  652.  
  653.  
  654.  
  655. class MSRPCBindNak(ImpactPacket.Header):
  656.     _SIZE = 24
  657.     
  658.     def __init__(self, aBuffer = None):
  659.         ImpactPacket.Header.__init__(self, self._SIZE)
  660.         self.set_type(MSRPC_BINDNAK)
  661.         if aBuffer:
  662.             self.load_header(aBuffer)
  663.         
  664.  
  665.     
  666.     def get_version(self):
  667.         ''' This method returns a tuple in (major, minor) form.'''
  668.         return (self.get_byte(0), self.get_byte(1))
  669.  
  670.     
  671.     def set_version(self, version):
  672.         ''' This method takes a tuple in (major, minor) form.'''
  673.         self.set_byte(0, version[0])
  674.         self.set_byte(1, version[1])
  675.  
  676.     
  677.     def get_type(self):
  678.         return self.get_byte(2)
  679.  
  680.     
  681.     def set_type(self, type):
  682.         self.set_byte(2, type)
  683.  
  684.     
  685.     def get_flags(self):
  686.         return self.get_byte(3)
  687.  
  688.     
  689.     def set_flags(self, flags):
  690.         self.set_byte(3, flags)
  691.  
  692.     
  693.     def get_representation(self):
  694.         return self.get_long(4, '<')
  695.  
  696.     
  697.     def set_representation(self, representation):
  698.         self.set_long(4, representation, '<')
  699.  
  700.     
  701.     def get_frag_len(self):
  702.         return self.get_word(8, '<')
  703.  
  704.     
  705.     def set_frag_len(self, len):
  706.         self.set_word(8, len, '<')
  707.  
  708.     
  709.     def get_auth_len(self):
  710.         return self.get_word(10, '<')
  711.  
  712.     
  713.     def set_auth_len(self, len):
  714.         self.set_word(10, len, '<')
  715.  
  716.     
  717.     def get_call_id(self):
  718.         return self.get_long(12, '<')
  719.  
  720.     
  721.     def set_call_id(self, id):
  722.         self.set_long(12, id, '<')
  723.  
  724.     
  725.     def get_reason(self):
  726.         return self.get_word(16, '<')
  727.  
  728.     
  729.     def set_reason(self, reason):
  730.         self.set_word(16, reason, '<')
  731.  
  732.     
  733.     def get_assoc_group(self):
  734.         return self.get_long(20, '<')
  735.  
  736.     
  737.     def set_assoc_group(self, id):
  738.         self.set_long(20, id, '<')
  739.  
  740.     
  741.     def get_header_size(self):
  742.         return self._SIZE
  743.  
  744.  
  745.  
  746. class DCERPC:
  747.     _max_ctx = 0
  748.     
  749.     def __init__(self, transport):
  750.         self._transport = transport
  751.         self.set_ctx_id(0)
  752.         self._max_frag = None
  753.         self.set_default_max_fragment_size()
  754.  
  755.     
  756.     def set_ctx_id(self, ctx_id):
  757.         self._ctx = ctx_id
  758.  
  759.     
  760.     def connect(self):
  761.         return self._transport.connect()
  762.  
  763.     
  764.     def disconnect(self):
  765.         return self._transport.disconnect()
  766.  
  767.     
  768.     def set_max_fragment_size(self, fragment_size):
  769.         if fragment_size == -1:
  770.             self.set_default_max_fragment_size()
  771.         else:
  772.             self._max_frag = fragment_size
  773.  
  774.     
  775.     def set_default_max_fragment_size(self):
  776.         self._max_frag = 0
  777.  
  778.     
  779.     def send(self, data):
  780.         raise RuntimeError, 'virtual method. Not implemented in subclass'
  781.  
  782.     
  783.     def recv(self):
  784.         raise RuntimeError, 'virtual method. Not implemented in subclass'
  785.  
  786.     
  787.     def alter_ctx(self, newUID, bogus_binds = ''):
  788.         raise RuntimeError, 'virtual method. Not implemented in subclass'
  789.  
  790.     
  791.     def set_credentials(self, username, password):
  792.         pass
  793.  
  794.     
  795.     def set_auth_level(self, auth_level):
  796.         pass
  797.  
  798.     
  799.     def get_idempotent(self):
  800.         return 0
  801.  
  802.     
  803.     def set_idempotent(self, flag):
  804.         pass
  805.  
  806.     
  807.     def call(self, function, body):
  808.         return self.send(DCERPC_RawCall(function, str(body)))
  809.  
  810.  
  811.  
  812. class DCERPC_v5(DCERPC):
  813.     endianness = '<'
  814.     
  815.     def __init__(self, transport):
  816.         DCERPC.__init__(self, transport)
  817.         self._DCERPC_v5__auth_level = ntlm.NTLM_AUTH_NONE
  818.         self._DCERPC_v5__username = None
  819.         self._DCERPC_v5__password = None
  820.  
  821.     
  822.     def set_auth_level(self, auth_level):
  823.         self._DCERPC_v5__auth_level = auth_level
  824.  
  825.     
  826.     def set_credentials(self, username, password):
  827.         self.set_auth_level(ntlm.NTLM_AUTH_CONNECT)
  828.         self._DCERPC_v5__username = username
  829.         self._DCERPC_v5__password = password
  830.  
  831.     
  832.     def bind(self, uuid, alter = 0, bogus_binds = 0):
  833.         bind = MSRPCBind(endianness = self.endianness)
  834.         syntax = '\x04]\x88\x8a\xeb\x1c\xc9\x11\x9f\xe8\x08\x00+\x10H`'
  835.         if self.endianness == '>':
  836.             syntax = unpack('<LHHBB6s', syntax)
  837.             syntax = pack('>LHHBB6s', *syntax)
  838.             uuid = list(unpack('<LHHBB6sHH', uuid))
  839.             uuid[-1] ^= uuid[-2]
  840.             uuid[-2] ^= uuid[-1]
  841.             uuid[-1] ^= uuid[-2]
  842.             uuid = pack('>LHHBB6sHH', *uuid)
  843.         
  844.         ctx = 0
  845.         for i in range(bogus_binds):
  846.             bind.set_ctx_id(self._ctx, index = ctx)
  847.             bind.set_trans_num(1, index = ctx)
  848.             bind.set_if_binuuid('A' * 20, index = ctx)
  849.             bind.set_xfer_syntax_binuuid(syntax, index = ctx)
  850.             bind.set_xfer_syntax_ver(2, index = ctx)
  851.             self._ctx += 1
  852.             ctx += 1
  853.         
  854.         bind.set_ctx_id(self._ctx, index = ctx)
  855.         bind.set_trans_num(1, index = ctx)
  856.         bind.set_if_binuuid(uuid, index = ctx)
  857.         bind.set_xfer_syntax_binuuid(syntax, index = ctx)
  858.         bind.set_xfer_syntax_ver(2, index = ctx)
  859.         bind.set_ctx_num(ctx + 1)
  860.         if alter:
  861.             bind.set_type(MSRPC_ALTERCTX)
  862.         
  863.         if self._DCERPC_v5__auth_level != ntlm.NTLM_AUTH_NONE:
  864.             if self._DCERPC_v5__username is None or self._DCERPC_v5__password is None:
  865.                 (self._DCERPC_v5__username, self._DCERPC_v5__password, nth, lmh) = self._transport.get_credentials()
  866.             
  867.             auth = ntlm.NTLMAuthNegotiate()
  868.             auth['auth_level'] = self._DCERPC_v5__auth_level
  869.             auth['auth_ctx_id'] = self._ctx + 79231
  870.             bind.set_auth_data(str(auth))
  871.         
  872.         self._transport.send(bind.get_packet())
  873.         s = self._transport.recv()
  874.         if s != 0:
  875.             resp = MSRPCBindAck(s)
  876.         else:
  877.             return 0
  878.         if resp.get_type() == MSRPC_BINDNAK:
  879.             resp = MSRPCBindNak(s)
  880.             status_code = resp.get_reason()
  881.             if rpc_status_codes.has_key(status_code):
  882.                 raise Exception(rpc_status_codes[status_code], resp)
  883.             else:
  884.                 raise Exception('Unknown DCE RPC fault status code: %.8x' % status_code, resp)
  885.         
  886.         self._DCERPC_v5__max_xmit_size = resp.get_max_tfrag()
  887.         if self._DCERPC_v5__auth_level != ntlm.NTLM_AUTH_NONE:
  888.             authResp = ntlm.NTLMAuthChallenge(data = resp.get_auth_data().tostring())
  889.             self._ntlm_challenge = authResp['challenge']
  890.             response = ntlm.NTLMAuthChallengeResponse(self._DCERPC_v5__username, self._DCERPC_v5__password, self._ntlm_challenge)
  891.             response['auth_ctx_id'] = self._ctx + 79231
  892.             response['auth_level'] = self._DCERPC_v5__auth_level
  893.             if self._DCERPC_v5__auth_level in (ntlm.NTLM_AUTH_CONNECT, ntlm.NTLM_AUTH_PKT_INTEGRITY, ntlm.NTLM_AUTH_PKT_PRIVACY):
  894.                 if self._DCERPC_v5__password:
  895.                     key = ntlm.compute_nthash(self._DCERPC_v5__password)
  896.                     if POW:
  897.                         hash = POW.Digest(POW.MD4_DIGEST)
  898.                     else:
  899.                         hash = MD4.new()
  900.                     hash.update(key)
  901.                     key = hash.digest()
  902.                 else:
  903.                     key = '\x00' * 16
  904.             
  905.             if POW:
  906.                 cipher = POW.Symmetric(POW.RC4)
  907.                 cipher.encryptInit(key)
  908.                 self.cipher_encrypt = cipher.update
  909.             else:
  910.                 cipher = ARC4.new(key)
  911.                 self.cipher_encrypt = cipher.encrypt
  912.             if response['flags'] & ntlm.NTLMSSP_KEY_EXCHANGE:
  913.                 session_key = 'A' * 16
  914.                 response['session_key'] = self.cipher_encrypt(session_key)
  915.                 if POW:
  916.                     cipher = POW.Symmetric(POW.RC4)
  917.                     cipher.encryptInit(session_key)
  918.                     self.cipher_encrypt = cipher.update
  919.                 else:
  920.                     cipher = ARC4.new(session_key)
  921.                     self.cipher_encrypt = cipher.encrypt
  922.             
  923.             self.sequence = 0
  924.             auth3 = MSRPCHeader()
  925.             auth3.set_type(MSRPC_AUTH3)
  926.             auth3.set_auth_data(str(response))
  927.             self._transport.send(auth3.get_packet(), forceWriteAndx = 1)
  928.         
  929.         return resp
  930.  
  931.     
  932.     def _transport_send(self, rpc_packet, forceWriteAndx = 0, forceRecv = 0):
  933.         if self._DCERPC_v5__auth_level == ntlm.NTLM_AUTH_CALL:
  934.             if rpc_packet.get_type() == MSRPC_REQUEST:
  935.                 response = ntlm.NTLMAuthChallengeResponse(self._DCERPC_v5__username, self._DCERPC_v5__password, self._ntlm_challenge)
  936.                 response['auth_ctx_id'] = self._ctx + 79231
  937.                 response['auth_level'] = self._DCERPC_v5__auth_level
  938.                 rpc_packet.set_auth_data(str(response))
  939.             
  940.         
  941.         if self._DCERPC_v5__auth_level in [
  942.             ntlm.NTLM_AUTH_PKT_INTEGRITY,
  943.             ntlm.NTLM_AUTH_PKT_PRIVACY]:
  944.             verifier = ntlm.NTLMAuthVerifier()
  945.             verifier['auth_level'] = self._DCERPC_v5__auth_level
  946.             verifier['auth_ctx_id'] = self._ctx + 79231
  947.             verifier['data'] = ' ' * 12
  948.             rpc_packet.set_auth_data(str(verifier))
  949.             rpc_call = rpc_packet.child()
  950.             if self._DCERPC_v5__auth_level == ntlm.NTLM_AUTH_PKT_PRIVACY:
  951.                 data = DCERPC_RawCall(rpc_call.OP_NUM)
  952.                 data.setData(self.cipher_encrypt(rpc_call.get_packet()))
  953.                 rpc_packet.contains(data)
  954.             
  955.             crc = crc32(rpc_call.get_packet())
  956.             data = pack('<LLL', 0, crc, self.sequence)
  957.             data = self.cipher_encrypt(data)
  958.             verifier['data'] = data
  959.             rpc_packet.set_auth_data(str(verifier))
  960.             self.sequence += 1
  961.         
  962.         self._transport.send(rpc_packet.get_packet(), forceWriteAndx = forceWriteAndx, forceRecv = forceRecv)
  963.  
  964.     
  965.     def send(self, data):
  966.         rpc = MSRPCRequestHeader(endianness = self.endianness)
  967.         rpc.set_ctx_id(self._ctx)
  968.         max_frag = self._max_frag
  969.         if data.get_size() > self._DCERPC_v5__max_xmit_size - 32:
  970.             max_frag = self._DCERPC_v5__max_xmit_size - 32
  971.         
  972.         if self._max_frag:
  973.             max_frag = min(max_frag, self._max_frag)
  974.         
  975.         if max_frag:
  976.             packet = str(data.get_bytes().tostring())
  977.             offset = 0
  978.             rawcall = DCERPC_RawCall(data.OP_NUM)
  979.             while None:
  980.                 toSend = packet[offset:offset + max_frag]
  981.                 if not toSend:
  982.                     break
  983.                 
  984.                 flags = 0
  985.                 if offset == 0:
  986.                     flags |= MSRPC_FIRSTFRAG
  987.                 
  988.                 offset += len(toSend)
  989.                 if offset == len(packet):
  990.                     flags |= MSRPC_LASTFRAG
  991.                 
  992.                 rawcall.setData(toSend)
  993.                 rpc.contains(rawcall)
  994.                 self._transport_send(rpc, forceWriteAndx = 1, forceRecv = flags & MSRPC_LASTFRAG)
  995.         else:
  996.             rpc.contains(data)
  997.             self._transport_send(rpc)
  998.  
  999.     
  1000.     def recv(self):
  1001.         self.response_data = self._transport.recv()
  1002.         self.response_header = MSRPCRespHeader(self.response_data)
  1003.         off = self.response_header.get_header_size()
  1004.         if self.response_header.get_type() == MSRPC_FAULT and self.response_header.get_frag_len() >= off + 4:
  1005.             status_code = unpack('<L', self.response_data[off:off + 4])[0]
  1006.             if rpc_status_codes.has_key(status_code):
  1007.                 raise Exception(rpc_status_codes[status_code])
  1008.             else:
  1009.                 raise Exception('Unknown DCE RPC fault status code: %.8x' % status_code)
  1010.         
  1011.         answer = self.response_data[off:]
  1012.         auth_len = self.response_header.get_auth_len()
  1013.         if auth_len:
  1014.             auth_len += 8
  1015.             auth_data = answer[-auth_len:]
  1016.             ntlmssp = ntlm.NTLMAuthHeader(data = auth_data)
  1017.             answer = answer[:-auth_len]
  1018.             if ntlmssp['auth_level'] == ntlm.NTLM_AUTH_PKT_PRIVACY:
  1019.                 answer = self.cipher_encrypt(answer)
  1020.             
  1021.             if ntlmssp['auth_pad_len']:
  1022.                 answer = answer[:-ntlmssp['auth_pad_len']]
  1023.             
  1024.             if ntlmssp['auth_level'] in [
  1025.                 ntlm.NTLM_AUTH_PKT_INTEGRITY,
  1026.                 ntlm.NTLM_AUTH_PKT_PRIVACY]:
  1027.                 ntlmssp = ntlm.NTLMAuthVerifier(data = auth_data)
  1028.                 data = self.cipher_encrypt(ntlmssp['data'])
  1029.                 (zero, crc, sequence) = unpack('<LLL', data)
  1030.                 self.sequence = sequence + 1
  1031.             
  1032.         
  1033.         return answer
  1034.  
  1035.     
  1036.     def alter_ctx(self, newUID, bogus_binds = 0):
  1037.         answer = self.__class__(self._transport)
  1038.         answer.set_credentials(self._DCERPC_v5__username, self._DCERPC_v5__password)
  1039.         answer.set_auth_level(self._DCERPC_v5__auth_level)
  1040.         self._max_ctx += 1
  1041.         answer.set_ctx_id(self._max_ctx)
  1042.         answer.bind(newUID, alter = 1, bogus_binds = bogus_binds)
  1043.         return answer
  1044.  
  1045.  
  1046.  
  1047. class DCERPC_RawCall(ImpactPacket.Header):
  1048.     
  1049.     def __init__(self, op_num, data = ''):
  1050.         self.OP_NUM = op_num
  1051.         ImpactPacket.Header.__init__(self)
  1052.         self.setData(data)
  1053.  
  1054.     
  1055.     def setData(self, data):
  1056.         self.get_bytes()[:] = array.array('B', data)
  1057.  
  1058.     
  1059.     def get_header_size(self):
  1060.         return len(self.get_bytes())
  1061.  
  1062.  
  1063.